home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / puma.lha / puma / src / Parser.mi < prev    next >
Text File  |  1992-09-25  |  62KB  |  1,474 lines
  1. (* $Id: Parser.mi,v 2.8 1992/08/12 06:54:05 grosch rel $ *)
  2.  
  3. IMPLEMENTATION MODULE Parser;
  4.  
  5. IMPORT SYSTEM, Scanner, Positions, Errors, Strings, DynArray, Sets, System;
  6.  
  7. (* line 2 "Parser.lalr" *)
  8.  
  9.  
  10.  
  11. FROM StringMem    IMPORT GetString, PutString;
  12. FROM Strings    IMPORT tString, SubString, Length, ArrayToString, IntToString, Concatenate;
  13. FROM Idents    IMPORT tIdent, NoIdent, MakeIdent;
  14. FROM Texts    IMPORT tText, MakeText;
  15. FROM Scanner    IMPORT BeginScanner, tScanAttribute, Attribute, Warning;
  16. FROM Positions    IMPORT tPosition, NoPosition;
  17.  
  18. FROM Tree    IMPORT
  19.    mSpec    , mCodes    , mAttrDesc    , mDesignator    ,
  20.    mLayoutAny    , mNoLayout    , mAnys        ,
  21.    mNoDesignator, mIdent    , mAny        , mNamedExpr    ,
  22.    mNoName    , mName        , mNoTreeName    , mTreeName    ,
  23.    mNoRoutine    , mPredicate    , mProcedure    , mFunction    ,
  24.    mType    , mNoParameter    , mParam    , mNoRule    ,
  25.    mRule    , mNoExpr    , mCompose    , mVarUse    ,
  26.    mTargetExpr    , mDontCare1    , mDontCare    , mOneExpr    ,
  27.    mNoStatement    , mTargetStmt    , mAssignment    , mCall        ,
  28.    mBinary    , mPreOperator    , mPostOperator    , mParents    ,
  29.    mProcCall    , mReject    , mFail        , mNl        ,
  30.    mStringExpr    , mNil        , mIndex    , Nil        ,
  31.    mOnePatternsList, mNoPatternsList    , OnePatternsList    ,
  32.    tTree    , Compose    , VarUse    , CopyTree    ,
  33.    TreeRoot    , MakeTree    , Codes        , ReverseTree    ;
  34.  
  35. VAR
  36.    String1, String2    : tString;
  37.    NameCount        : INTEGER;
  38.    Line            : tPosition;
  39.    nNoParameter, nNoName, nNoRule, nNoDesignator,
  40.    nNoStatement, nNoLayout, nNoPatternsList: tTree;
  41.  
  42. PROCEDURE mRules (Line: tPosition; Patterns, Exprs, Expr, Statements, Next: tTree): tTree;
  43.    VAR Tree    : tTree;
  44.    BEGIN
  45.       Tree := mRule (Line, Patterns^.OnePatternsList.Patterns, Exprs, Expr, Statements, Next);
  46.       Patterns := Patterns^.OnePatternsList.Next;
  47.       WHILE Patterns^.Kind = OnePatternsList DO
  48.      Tree := mRule (Line, Patterns^.OnePatternsList.Patterns, CopyTree (Exprs),
  49.             CopyTree (Expr), CopyTree (Statements), Tree);
  50.      Patterns := Patterns^.OnePatternsList.Next;
  51.       END;
  52.       RETURN Tree;
  53.    END mRules;
  54.  
  55. TYPE
  56. yyTrafoName = RECORD Id: tIdent; END;
  57. yyTreePart = RECORD Tree: tTree; END;
  58. yyTreeNames = RECORD Tree: tTree; END;
  59. yyPublicPart = RECORD Tree: tTree; END;
  60. yyExternPart0 = RECORD Tree: tTree; END;
  61. yyExternPart = RECORD Tree: tTree; END;
  62. yyNames = RECORD Tree: tTree; END;
  63. yyCodes = RECORD Tree: tTree; END;
  64. yyRoutines = RECORD Tree: tTree; END;
  65. yyOutParameters = RECORD Tree: tTree; END;
  66. yyParameters = RECORD Tree: tTree; END;
  67. yyMode = RECORD IsRef: BOOLEAN; END;
  68. yyDeclarations = RECORD Tree: tTree; END;
  69. yyType = RECORD Tree: tTree; END;
  70. yyLocalCode = RECORD Text: tText; Position: tPosition; END;
  71. yyRules = RECORD Tree: tTree; END;
  72. yyPatterns = RECORD Tree: tTree; END;
  73. yyPatterns2 = RECORD Tree: tTree; END;
  74. yyExprs = RECORD Tree: tTree; END;
  75. yyNamedExprs = RECORD Tree: tTree; END;
  76. yyExprs2 = RECORD Tree: tTree; END;
  77. yyNamedExprs2 = RECORD Tree: tTree; END;
  78. yyExpr = RECORD Tree: tTree; END;
  79. yyPrefixExpr = RECORD Tree: tTree; END;
  80. yyPostfixExpr = RECORD Tree: tTree; END;
  81. yyPrimaryExpr = RECORD Tree: tTree; END;
  82. yyStatements = RECORD Tree: tTree; END;
  83. yyTargetCodes = RECORD Tree: tTree; END;
  84. yyName0 = RECORD Id: tIdent; Position: tPosition; END;
  85. yyName1 = RECORD Id: tIdent; Position: tPosition; END;
  86. yySpace = RECORD Tree: tTree; END;
  87.  
  88. tParsAttribute = RECORD CASE : SHORTCARD OF
  89.   0: Scan: Scanner.tScanAttribute;
  90. | 1: TrafoName: yyTrafoName;
  91. | 2: TreePart: yyTreePart;
  92. | 3: TreeNames: yyTreeNames;
  93. | 4: PublicPart: yyPublicPart;
  94. | 5: ExternPart0: yyExternPart0;
  95. | 6: ExternPart: yyExternPart;
  96. | 7: Names: yyNames;
  97. | 8: Codes: yyCodes;
  98. | 9: Routines: yyRoutines;
  99. | 10: OutParameters: yyOutParameters;
  100. | 11: Parameters: yyParameters;
  101. | 12: Mode: yyMode;
  102. | 13: Declarations: yyDeclarations;
  103. | 14: Type: yyType;
  104. | 15: LocalCode: yyLocalCode;
  105. | 16: Rules: yyRules;
  106. | 17: Patterns: yyPatterns;
  107. | 18: Patterns2: yyPatterns2;
  108. | 19: Exprs: yyExprs;
  109. | 20: NamedExprs: yyNamedExprs;
  110. | 21: Exprs2: yyExprs2;
  111. | 22: NamedExprs2: yyNamedExprs2;
  112. | 23: Expr: yyExpr;
  113. | 24: PrefixExpr: yyPrefixExpr;
  114. | 25: PostfixExpr: yyPostfixExpr;
  115. | 26: PrimaryExpr: yyPrimaryExpr;
  116. | 27: Statements: yyStatements;
  117. | 28: TargetCodes: yyTargetCodes;
  118. | 29: Name0: yyName0;
  119. | 30: Name1: yyName1;
  120. | 31: Space: yySpace;
  121. END; END;
  122.  
  123.  
  124. CONST
  125.    yyInitStackSize    = 100;
  126.    yyNoState        = 0;
  127.  
  128.    yyFirstTerminal        = 0;
  129.    yyLastTerminal        = 47;
  130.    yyFirstSymbol        = 0;
  131.    yyLastSymbol        = 82;
  132.    yyTableMax        = 682;
  133.    yyNTableMax        = 252;
  134.    yyFirstReadState        = 1;
  135.    yyLastReadState        = 159;
  136.    yyFirstReadTermState        = 160;
  137.    yyLastReadTermState        = 216;
  138.    yyLastReadNontermState        = 238;
  139.    yyFirstReduceState        = 239;
  140.    yyLastReduceState        = 362;
  141.    yyStartState        = 1;
  142.    yyStopState        = 239;
  143.  
  144.    yyFirstFinalState    = yyFirstReadTermState;
  145.    yyLastState        = yyLastReduceState;
  146.  
  147. TYPE
  148.    yyTableElmt        = SHORTCARD;
  149.    yyTCombRange        = yyTableElmt [0 .. yyTableMax];
  150.    yyNCombRange        = yyTableElmt [yyLastTerminal + 1 .. yyNTableMax];
  151.    yyStateRange        = yyTableElmt [0 .. yyLastState];
  152.    yyReadRange        = yyTableElmt [yyFirstReadState .. yyLastReadState];
  153.    yyReadReduceRange    = yyTableElmt [yyFirstReadTermState ..yyLastReadNontermState];
  154.    yyReduceRange    = yyTableElmt [yyFirstReduceState .. yyLastReduceState];
  155.    yySymbolRange    = yyTableElmt [yyFirstSymbol .. yyLastSymbol];
  156.    yyTCombType        = RECORD Check, Next: yyStateRange; END;
  157.    yyNCombType        = yyStateRange;
  158.    yyTCombTypePtr    = POINTER TO yyTCombType;
  159.    yyNCombTypePtr    = POINTER TO yyNCombType;
  160.    yyStackType        = POINTER TO ARRAY [0 .. 1000000] OF yyStateRange;
  161.  
  162. VAR
  163.    yyTBasePtr        : ARRAY [0 .. yyLastReadState]    OF yyTCombTypePtr;
  164.    yyNBasePtr        : ARRAY [0 .. yyLastReadState]    OF yyNCombTypePtr;
  165.    yyDefault        : ARRAY [0 .. yyLastReadState]    OF yyReadRange    ;
  166.    yyTComb        : ARRAY yyTCombRange        OF yyTCombType    ;
  167.    yyNComb        : ARRAY yyNCombRange        OF yyNCombType    ;
  168.    yyLength        : ARRAY yyReduceRange        OF yyTableElmt    ;
  169.    yyLeftHandSide    : ARRAY yyReduceRange        OF yySymbolRange;
  170.    yyContinuation    : ARRAY [0 .. yyLastReadState]    OF yySymbolRange;
  171.    yyFinalToProd    : ARRAY yyReadReduceRange    OF yyReduceRange;
  172.    yyIsInitialized    : BOOLEAN;
  173.    yyTableFile        : System.tFile;
  174.  
  175. PROCEDURE TokenName (Token: CARDINAL; VAR Name: ARRAY OF CHAR);
  176.    PROCEDURE Copy (Source: ARRAY OF CHAR; VAR Target: ARRAY OF CHAR);
  177.       VAR i, j: CARDINAL;
  178.       BEGIN
  179.      IF HIGH (Source) < HIGH (Target)
  180.      THEN j := HIGH (Source); ELSE j := HIGH (Target); END;
  181.      FOR i := 0 TO j DO Target [i] := Source [i]; END;
  182.      IF HIGH (Target) > j THEN Target [j + 1] := CHR (0); END;
  183.       END Copy;
  184.    BEGIN
  185.       CASE Token OF
  186.       | 0: Copy ("_EndOfFile", Name);
  187.       | 1: Copy ("Ident", Name);
  188.       | 2: Copy ("Operator", Name);
  189.       | 3: Copy ("IncOperator", Name);
  190.       | 4: Copy ("TargetBlock", Name);
  191.       | 5: Copy ("String", Name);
  192.       | 6: Copy ("Number", Name);
  193.       | 7: Copy ("TargetCode", Name);
  194.       | 8: Copy ("WhiteSpace", Name);
  195.       | 9: Copy ('::', Name);
  196.       | 10: Copy ("TRAFO", Name);
  197.       | 11: Copy ('TREE', Name);
  198.       | 12: Copy (',', Name);
  199.       | 13: Copy ("PUBLIC", Name);
  200.       | 14: Copy ("EXTERN", Name);
  201.       | 15: Copy (';', Name);
  202.       | 16: Copy ('EXPORT', Name);
  203.       | 17: Copy ('IMPORT', Name);
  204.       | 18: Copy ('GLOBAL', Name);
  205.       | 19: Copy ('BEGIN', Name);
  206.       | 20: Copy ('CLOSE', Name);
  207.       | 21: Copy ("PROCEDURE", Name);
  208.       | 22: Copy ('(', Name);
  209.       | 23: Copy ("REF", Name);
  210.       | 24: Copy (':', Name);
  211.       | 25: Copy ('.', Name);
  212.       | 26: Copy ('[', Name);
  213.       | 27: Copy (']', Name);
  214.       | 28: Copy ('=>', Name);
  215.       | 29: Copy (')', Name);
  216.       | 30: Copy ('LOCAL', Name);
  217.       | 31: Copy ('..', Name);
  218.       | 32: Copy ("NIL", Name);
  219.       | 33: Copy ('_', Name);
  220.       | 34: Copy ('{', Name);
  221.       | 35: Copy ('}', Name);
  222.       | 36: Copy ('->', Name);
  223.       | 37: Copy ('^', Name);
  224.       | 38: Copy (':>', Name);
  225.       | 39: Copy (':=', Name);
  226.       | 40: Copy ('?', Name);
  227.       | 41: Copy ("REJECT", Name);
  228.       | 42: Copy ("FAIL", Name);
  229.       | 43: Copy ("NL", Name);
  230.       | 44: Copy ("RETURN", Name);
  231.       | 45: Copy ('FUNCTION', Name);
  232.       | 46: Copy ("PREDICATE", Name);
  233.       | 47: Copy ("HIGH", Name);
  234.       END;
  235.    END TokenName;
  236.  
  237. PROCEDURE Parser (): CARDINAL;
  238. (* line 121 "Parser.lalr" *)
  239.  
  240.  
  241.    VAR
  242.       yyState        : yyStateRange;
  243.       yyTerminal    : yySymbolRange;
  244.       yyNonterminal    : yySymbolRange;    (* left-hand side symbol *)
  245.       yyStackPtr    : yyTableElmt;
  246.       yyStateStackSize    : LONGINT;
  247.       yyAttrStackSize    : LONGINT;
  248.       yyShortStackSize    : yyTableElmt;
  249.       yyStateStack    : yyStackType;
  250.       yyAttributeStack    : POINTER TO ARRAY [0 .. 1000000] OF tParsAttribute;
  251.       yySynAttribute    : tParsAttribute;    (* synthesized attribute *)
  252.       yyRepairAttribute : Scanner.tScanAttribute;
  253.       yyRepairToken    : yySymbolRange;
  254.       yyTCombPtr    : yyTCombTypePtr;
  255.       yyNCombPtr    : yyNCombTypePtr;
  256.       yyIsRepairing    : BOOLEAN;
  257.       yyErrorCount    : CARDINAL;
  258.       yyTokenString    : ARRAY [0..127] OF CHAR;
  259.    BEGIN
  260.       BeginParser;
  261.       yyState        := yyStartState;
  262.       yyTerminal    := Scanner.GetToken ();
  263.       yyStateStackSize    := yyInitStackSize;
  264.       yyAttrStackSize    := yyInitStackSize;
  265.       DynArray.MakeArray (yyStateStack, yyStateStackSize, SYSTEM.TSIZE (yyStateRange));
  266.       DynArray.MakeArray (yyAttributeStack, yyAttrStackSize, SYSTEM.TSIZE (tParsAttribute));
  267.       yyShortStackSize    := yyStateStackSize - 1;
  268.       yyStackPtr    := 0;
  269.       yyErrorCount    := 0;
  270.       yyIsRepairing    := FALSE;
  271.  
  272.       LOOP
  273.      IF yyStackPtr >= yyShortStackSize THEN
  274.         DynArray.ExtendArray (yyStateStack, yyStateStackSize, SYSTEM.TSIZE (yyStateRange));
  275.         DynArray.ExtendArray (yyAttributeStack, yyAttrStackSize, SYSTEM.TSIZE (tParsAttribute));
  276.         yyShortStackSize := yyStateStackSize - 1;
  277.      END;
  278.      yyStateStack^ [yyStackPtr] := yyState;
  279.  
  280.      LOOP    (* SPEC State := Next (State, Terminal); terminal transition *)
  281.         yyTCombPtr := yyTCombTypePtr (LONGCARD (yyTBasePtr [yyState]) 
  282.                  + yyTerminal * SYSTEM.TSIZE (yyTCombType));
  283.         IF yyTCombPtr^.Check = yyState THEN
  284.            yyState := yyTCombPtr^.Next;
  285.            EXIT;
  286.         END;
  287.         yyState := yyDefault [yyState];
  288.  
  289.         IF yyState = yyNoState THEN            (* syntax error *)
  290.            yyState := yyStateStack^ [yyStackPtr];
  291.            IF yyIsRepairing THEN            (* repair *)
  292.           yyRepairToken := yyContinuation [yyState];
  293.           yyState := Next (yyState, yyRepairToken);
  294.           IF yyState <= yyLastReadTermState THEN (* read or read terminal reduce ? *)
  295.              Scanner.ErrorAttribute (yyRepairToken, yyRepairAttribute);
  296.              TokenName (yyRepairToken, yyTokenString);
  297.              Errors.ErrorMessageI (Errors.TokenInserted, Errors.Repair,
  298.             Scanner.Attribute.Position, Errors.Array, SYSTEM.ADR (yyTokenString));
  299.              IF yyState >= yyFirstFinalState THEN (* avoid second push *)
  300.             yyState := yyFinalToProd [yyState];
  301.              END;
  302.              INC (yyStackPtr);
  303.              yyAttributeStack^ [yyStackPtr].Scan := yyRepairAttribute;
  304.              yyStateStack^     [yyStackPtr] := yyState;
  305.           END;
  306.           IF yyState >= yyFirstFinalState THEN    (* final state ? *)
  307.             EXIT;
  308.           END;
  309.            ELSE                    (* report and recover *)
  310.           INC (yyErrorCount);
  311.           ErrorRecovery (yyTerminal, yyStateStack, yyStateStackSize, yyStackPtr);
  312.           yyIsRepairing := TRUE;
  313.            END;
  314.         END;
  315.      END;
  316.  
  317.      IF yyState >= yyFirstFinalState THEN        (* final state ? *)
  318.         IF yyState <= yyLastReadTermState THEN    (* read terminal reduce ? *)
  319.            INC (yyStackPtr);
  320.            yyAttributeStack^ [yyStackPtr].Scan := Scanner.Attribute;
  321.            yyTerminal := Scanner.GetToken ();
  322.            yyIsRepairing := FALSE;
  323.         END;
  324.  
  325.         LOOP                    (* reduce *)
  326. CASE yyState OF
  327.   | 239: (* _0000_ : Trafo _EndOfFile .*)
  328.   DynArray.ReleaseArray (yyStateStack, yyStateStackSize, SYSTEM.TSIZE (yyTableElmt));
  329.   DynArray.ReleaseArray (yyAttributeStack, yyAttrStackSize, SYSTEM.TSIZE (tParsAttribute));
  330.   RETURN yyErrorCount;
  331.  
  332.   | 240: (* Trafo : TrafoName TreePart PublicPart ExternPart0 Codes Routines .*)
  333.   DEC (yyStackPtr, 6); yyNonterminal := 54;
  334. (* line 197 "Parser.lalr" *)
  335.    ;
  336.    TreeRoot := mSpec (yyAttributeStack^[yyStackPtr+1].TrafoName.Id, yyAttributeStack^[yyStackPtr+2].TreePart.Tree, yyAttributeStack^[yyStackPtr+3].PublicPart.Tree,
  337.            yyAttributeStack^[yyStackPtr+4].ExternPart0.Tree, yyAttributeStack^[yyStackPtr+5].Codes.Tree, ReverseTree (yyAttributeStack^[yyStackPtr+6].Routines.Tree)); ;
  338.    ;
  339.   
  340.   | 241: (* TrafoName : .*)
  341.   DEC (yyStackPtr, 0); yyNonterminal := 48;
  342. (* line 202 "Parser.lalr" *)
  343.    ArrayToString ("Trafo", String1); yySynAttribute.TrafoName.Id := MakeIdent (String1); ;
  344.     ;
  345.   
  346.   | 242,217: (* TrafoName : TRAFO Name0 .*)
  347.   DEC (yyStackPtr, 2); yyNonterminal := 48;
  348. (* line 205 "Parser.lalr" *)
  349.   yySynAttribute.TrafoName.Id := yyAttributeStack^[yyStackPtr+2].Name0.Id;
  350.   
  351.   | 243: (* TreePart : .*)
  352.   DEC (yyStackPtr, 0); yyNonterminal := 49;
  353. (* line 207 "Parser.lalr" *)
  354.    ArrayToString ("Tree", String1);
  355.           yySynAttribute.TreePart.Tree := mTreeName (MakeIdent (String1), Attribute.Position, mNoTreeName ()); ;
  356.    ;
  357.   
  358.   | 244: (* TreePart : 'TREE' TreeNames .*)
  359.   DEC (yyStackPtr, 2); yyNonterminal := 49;
  360. (* line 211 "Parser.lalr" *)
  361.    yySynAttribute.TreePart.Tree := ReverseTree (yyAttributeStack^[yyStackPtr+2].TreeNames.Tree);
  362.    ;
  363.   
  364.   | 245: (* TreeNames : .*)
  365.   DEC (yyStackPtr, 0); yyNonterminal := 56;
  366. (* line 214 "Parser.lalr" *)
  367.    yySynAttribute.TreeNames.Tree := mNoTreeName ();
  368.    ;
  369.   
  370.   | 246,162: (* TreeNames : TreeNames ',' .*)
  371.   DEC (yyStackPtr, 2); yyNonterminal := 56;
  372. (* line 217 "Parser.lalr" *)
  373.   yySynAttribute.TreeNames.Tree := yyAttributeStack^[yyStackPtr+1].TreeNames.Tree;
  374.   
  375.   | 247,218: (* TreeNames : TreeNames Name0 .*)
  376.   DEC (yyStackPtr, 2); yyNonterminal := 56;
  377. (* line 219 "Parser.lalr" *)
  378.    yySynAttribute.TreeNames.Tree := mTreeName (yyAttributeStack^[yyStackPtr+2].Name0.Id, yyAttributeStack^[yyStackPtr+2].Name0.Position, yyAttributeStack^[yyStackPtr+1].TreeNames.Tree);
  379.    ;
  380.   
  381.   | 248: (* PublicPart : .*)
  382.   DEC (yyStackPtr, 0); yyNonterminal := 50;
  383. (* line 222 "Parser.lalr" *)
  384.    yySynAttribute.PublicPart.Tree := nNoName;
  385.    ;
  386.   
  387.   | 249: (* PublicPart : PUBLIC Names .*)
  388.   DEC (yyStackPtr, 2); yyNonterminal := 50;
  389. (* line 225 "Parser.lalr" *)
  390.    yySynAttribute.PublicPart.Tree := ReverseTree (yyAttributeStack^[yyStackPtr+2].Names.Tree);
  391.    ;
  392.   
  393.   | 250: (* ExternPart0 : .*)
  394.   DEC (yyStackPtr, 0); yyNonterminal := 51;
  395. (* line 228 "Parser.lalr" *)
  396.    yySynAttribute.ExternPart0.Tree := nNoName;
  397.    ;
  398.   
  399.   | 251,220: (* ExternPart0 : EXTERN Names OptSemiColon .*)
  400.   DEC (yyStackPtr, 3); yyNonterminal := 51;
  401. (* line 231 "Parser.lalr" *)
  402.    yySynAttribute.ExternPart0.Tree := ReverseTree (yyAttributeStack^[yyStackPtr+2].Names.Tree);
  403.    ;
  404.   
  405.   | 252: (* ExternPart : .*)
  406.   DEC (yyStackPtr, 0); yyNonterminal := 59;
  407. (* line 234 "Parser.lalr" *)
  408.    yySynAttribute.ExternPart.Tree := nNoName;
  409.    ;
  410.   
  411.   | 253,173: (* ExternPart : EXTERN Names ';' .*)
  412.   DEC (yyStackPtr, 3); yyNonterminal := 59;
  413. (* line 237 "Parser.lalr" *)
  414.    yySynAttribute.ExternPart.Tree := ReverseTree (yyAttributeStack^[yyStackPtr+2].Names.Tree);
  415.    ;
  416.   
  417.   | 254: (* Names : .*)
  418.   DEC (yyStackPtr, 0); yyNonterminal := 57;
  419. (* line 240 "Parser.lalr" *)
  420.    yySynAttribute.Names.Tree := nNoName;
  421.    ;
  422.   
  423.   | 255,163: (* Names : Names ',' .*)
  424.   DEC (yyStackPtr, 2); yyNonterminal := 57;
  425. (* line 243 "Parser.lalr" *)
  426.   yySynAttribute.Names.Tree := yyAttributeStack^[yyStackPtr+1].Names.Tree;
  427.   
  428.   | 256,219: (* Names : Names Name0 .*)
  429.   DEC (yyStackPtr, 2); yyNonterminal := 57;
  430. (* line 245 "Parser.lalr" *)
  431.    yySynAttribute.Names.Tree := mName (yyAttributeStack^[yyStackPtr+2].Name0.Id, yyAttributeStack^[yyStackPtr+2].Name0.Position, yyAttributeStack^[yyStackPtr+1].Names.Tree);
  432.    ;
  433.   
  434.   | 257: (* Codes : .*)
  435.   DEC (yyStackPtr, 0); yyNonterminal := 52;
  436. (* line 248 "Parser.lalr" *)
  437.    yySynAttribute.Codes.Tree := MakeTree (Codes);
  438.    ;
  439.   
  440.   | 258,165: (* Codes : Codes 'EXPORT' TargetBlock .*)
  441.   DEC (yyStackPtr, 3); yyNonterminal := 52;
  442. (* line 251 "Parser.lalr" *)
  443.    yySynAttribute.Codes.Tree := yyAttributeStack^[yyStackPtr+1].Codes.Tree;
  444.           yySynAttribute.Codes.Tree^.Codes.Export     := yyAttributeStack^[yyStackPtr+3].Scan.TargetBlock.Text;
  445.           yySynAttribute.Codes.Tree^.Codes.ExportLine := yyAttributeStack^[yyStackPtr+3].Scan.Position; ;
  446.    ;
  447.   
  448.   | 259,166: (* Codes : Codes 'IMPORT' TargetBlock .*)
  449.   DEC (yyStackPtr, 3); yyNonterminal := 52;
  450. (* line 256 "Parser.lalr" *)
  451.    yySynAttribute.Codes.Tree := yyAttributeStack^[yyStackPtr+1].Codes.Tree;
  452.           yySynAttribute.Codes.Tree^.Codes.Import     := yyAttributeStack^[yyStackPtr+3].Scan.TargetBlock.Text;
  453.           yySynAttribute.Codes.Tree^.Codes.ImportLine := yyAttributeStack^[yyStackPtr+3].Scan.Position; ;
  454.    ;
  455.   
  456.   | 260,167: (* Codes : Codes 'GLOBAL' TargetBlock .*)
  457.   DEC (yyStackPtr, 3); yyNonterminal := 52;
  458. (* line 261 "Parser.lalr" *)
  459.    yySynAttribute.Codes.Tree := yyAttributeStack^[yyStackPtr+1].Codes.Tree;
  460.           yySynAttribute.Codes.Tree^.Codes.Global     := yyAttributeStack^[yyStackPtr+3].Scan.TargetBlock.Text;
  461.           yySynAttribute.Codes.Tree^.Codes.GlobalLine := yyAttributeStack^[yyStackPtr+3].Scan.Position; ;
  462.    ;
  463.   
  464.   | 261,168: (* Codes : Codes 'BEGIN' TargetBlock .*)
  465.   DEC (yyStackPtr, 3); yyNonterminal := 52;
  466. (* line 266 "Parser.lalr" *)
  467.    yySynAttribute.Codes.Tree := yyAttributeStack^[yyStackPtr+1].Codes.Tree;
  468.           yySynAttribute.Codes.Tree^.Codes.Begin      := yyAttributeStack^[yyStackPtr+3].Scan.TargetBlock.Text;
  469.           yySynAttribute.Codes.Tree^.Codes.BeginLine  := yyAttributeStack^[yyStackPtr+3].Scan.Position; ;
  470.    ;
  471.   
  472.   | 262,169: (* Codes : Codes 'CLOSE' TargetBlock .*)
  473.   DEC (yyStackPtr, 3); yyNonterminal := 52;
  474. (* line 271 "Parser.lalr" *)
  475.    yySynAttribute.Codes.Tree := yyAttributeStack^[yyStackPtr+1].Codes.Tree;
  476.           yySynAttribute.Codes.Tree^.Codes.Close      := yyAttributeStack^[yyStackPtr+3].Scan.TargetBlock.Text;
  477.           yySynAttribute.Codes.Tree^.Codes.CloseLine  := yyAttributeStack^[yyStackPtr+3].Scan.Position; ;
  478.    ;
  479.   
  480.   | 263: (* Routines : .*)
  481.   DEC (yyStackPtr, 0); yyNonterminal := 53;
  482. (* line 276 "Parser.lalr" *)
  483.    yySynAttribute.Routines.Tree := mNoRoutine ();
  484.    ;
  485.   
  486.   | 264: (* Routines : Routines PROCEDURE Name0 '(' Parameters OutParameters ')' ExternPart LocalCode Rules .*)
  487.   DEC (yyStackPtr, 10); yyNonterminal := 53;
  488. (* line 279 "Parser.lalr" *)
  489.    yySynAttribute.Routines.Tree := mProcedure (yyAttributeStack^[yyStackPtr+1].Routines.Tree, yyAttributeStack^[yyStackPtr+3].Name0.Id, yyAttributeStack^[yyStackPtr+3].Name0.Position,
  490.              yyAttributeStack^[yyStackPtr+5].Parameters.Tree, yyAttributeStack^[yyStackPtr+6].OutParameters.Tree, yyAttributeStack^[yyStackPtr+8].ExternPart.Tree, yyAttributeStack^[yyStackPtr+9].LocalCode.Text,
  491.              yyAttributeStack^[yyStackPtr+9].LocalCode.Position, ReverseTree (yyAttributeStack^[yyStackPtr+10].Rules.Tree));
  492.    ;
  493.   
  494.   | 265: (* Routines : Routines 'FUNCTION' Name0 '(' Parameters OutParameters ')' Type ExternPart LocalCode Rules .*)
  495.   DEC (yyStackPtr, 11); yyNonterminal := 53;
  496. (* line 284 "Parser.lalr" *)
  497.    yySynAttribute.Routines.Tree := mFunction (yyAttributeStack^[yyStackPtr+1].Routines.Tree, yyAttributeStack^[yyStackPtr+3].Name0.Id, yyAttributeStack^[yyStackPtr+3].Name0.Position,
  498.              yyAttributeStack^[yyStackPtr+5].Parameters.Tree, yyAttributeStack^[yyStackPtr+6].OutParameters.Tree, yyAttributeStack^[yyStackPtr+9].ExternPart.Tree, yyAttributeStack^[yyStackPtr+10].LocalCode.Text,
  499.              yyAttributeStack^[yyStackPtr+10].LocalCode.Position, ReverseTree (yyAttributeStack^[yyStackPtr+11].Rules.Tree),
  500.              mParam (FALSE, NoIdent, NoPosition, yyAttributeStack^[yyStackPtr+8].Type.Tree, nNoParameter));
  501.    ;
  502.   
  503.   | 266: (* Routines : Routines PREDICATE Name0 '(' Parameters OutParameters ')' ExternPart LocalCode Rules .*)
  504.   DEC (yyStackPtr, 10); yyNonterminal := 53;
  505. (* line 290 "Parser.lalr" *)
  506.    yySynAttribute.Routines.Tree := mPredicate (yyAttributeStack^[yyStackPtr+1].Routines.Tree, yyAttributeStack^[yyStackPtr+3].Name0.Id, yyAttributeStack^[yyStackPtr+3].Name0.Position,
  507.              yyAttributeStack^[yyStackPtr+5].Parameters.Tree, yyAttributeStack^[yyStackPtr+6].OutParameters.Tree, yyAttributeStack^[yyStackPtr+8].ExternPart.Tree, yyAttributeStack^[yyStackPtr+9].LocalCode.Text,
  508.              yyAttributeStack^[yyStackPtr+9].LocalCode.Position, ReverseTree (yyAttributeStack^[yyStackPtr+10].Rules.Tree));
  509.    ;
  510.   
  511.   | 267: (* OutParameters : .*)
  512.   DEC (yyStackPtr, 0); yyNonterminal := 61;
  513. (* line 295 "Parser.lalr" *)
  514.    yySynAttribute.OutParameters.Tree := nNoParameter;
  515.    ;
  516.   
  517.   | 268,221: (* OutParameters : '=>' Parameters .*)
  518.   DEC (yyStackPtr, 2); yyNonterminal := 61;
  519. (* line 298 "Parser.lalr" *)
  520.   yySynAttribute.OutParameters.Tree := yyAttributeStack^[yyStackPtr+2].Parameters.Tree;
  521.   
  522.   | 269: (* Parameters : .*)
  523.   DEC (yyStackPtr, 0); yyNonterminal := 60;
  524. (* line 300 "Parser.lalr" *)
  525.    yySynAttribute.Parameters.Tree := nNoParameter;
  526.    ;
  527.   
  528.   | 270: (* Parameters : Mode Ident ':' Type .*)
  529.   DEC (yyStackPtr, 4); yyNonterminal := 60;
  530. (* line 303 "Parser.lalr" *)
  531.    yySynAttribute.Parameters.Tree := mParam (yyAttributeStack^[yyStackPtr+1].Mode.IsRef, yyAttributeStack^[yyStackPtr+2].Scan.Ident.Ident, yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+4].Type.Tree, nNoParameter);
  532.    ;
  533.   
  534.   | 271: (* Parameters : Mode Type .*)
  535.   DEC (yyStackPtr, 2); yyNonterminal := 60;
  536. (* line 306 "Parser.lalr" *)
  537.    ArrayToString ("yyP", String1); INC (NameCount);
  538.              IntToString (NameCount, String2); Concatenate (String1, String2);
  539.              yySynAttribute.Parameters.Tree := mParam (yyAttributeStack^[yyStackPtr+1].Mode.IsRef, MakeIdent (String1), NoPosition, yyAttributeStack^[yyStackPtr+2].Type.Tree, nNoParameter); ;
  540.    ;
  541.   
  542.   | 272,223: (* Parameters : Mode Ident ':' Type ',' Parameters .*)
  543.   DEC (yyStackPtr, 6); yyNonterminal := 60;
  544. (* line 311 "Parser.lalr" *)
  545.    yySynAttribute.Parameters.Tree := mParam (yyAttributeStack^[yyStackPtr+1].Mode.IsRef, yyAttributeStack^[yyStackPtr+2].Scan.Ident.Ident, yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+4].Type.Tree, yyAttributeStack^[yyStackPtr+6].Parameters.Tree);
  546.    ;
  547.   
  548.   | 273,224: (* Parameters : Mode Type ',' Parameters .*)
  549.   DEC (yyStackPtr, 4); yyNonterminal := 60;
  550. (* line 314 "Parser.lalr" *)
  551.    ArrayToString ("yyP", String1); INC (NameCount);
  552.              IntToString (NameCount, String2); Concatenate (String1, String2);
  553.              yySynAttribute.Parameters.Tree := mParam (yyAttributeStack^[yyStackPtr+1].Mode.IsRef, MakeIdent (String1), NoPosition, yyAttributeStack^[yyStackPtr+2].Type.Tree, yyAttributeStack^[yyStackPtr+4].Parameters.Tree); ;
  554.    ;
  555.   
  556.   | 274: (* Mode : .*)
  557.   DEC (yyStackPtr, 0); yyNonterminal := 65;
  558. (* line 319 "Parser.lalr" *)
  559.    yySynAttribute.Mode.IsRef := FALSE;
  560.    ;
  561.   
  562.   | 275,170: (* Mode : REF .*)
  563.   DEC (yyStackPtr, 1); yyNonterminal := 65;
  564. (* line 322 "Parser.lalr" *)
  565.    yySynAttribute.Mode.IsRef := TRUE ;
  566.    ;
  567.   
  568.   | 276: (* Declarations : Ident ':' Type .*)
  569.   DEC (yyStackPtr, 3); yyNonterminal := 66;
  570. (* line 325 "Parser.lalr" *)
  571.    yySynAttribute.Declarations.Tree := mParam (FALSE, yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident, yyAttributeStack^[yyStackPtr+1].Scan.Position, yyAttributeStack^[yyStackPtr+3].Type.Tree, nNoParameter);
  572.    ;
  573.   
  574.   | 277,236: (* Declarations : Ident ':' Type ',' Declarations .*)
  575.   DEC (yyStackPtr, 5); yyNonterminal := 66;
  576. (* line 328 "Parser.lalr" *)
  577.    yySynAttribute.Declarations.Tree := mParam (FALSE, yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident, yyAttributeStack^[yyStackPtr+1].Scan.Position, yyAttributeStack^[yyStackPtr+3].Type.Tree, yyAttributeStack^[yyStackPtr+5].Declarations.Tree);
  578.    ;
  579.   
  580.   | 278: (* Type : Ident .*)
  581.   DEC (yyStackPtr, 1); yyNonterminal := 64;
  582. (* line 331 "Parser.lalr" *)
  583.    yySynAttribute.Type.Tree := mType (yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident, yyAttributeStack^[yyStackPtr+1].Scan.Position, nNoName);
  584.    ;
  585.   
  586.   | 279,222: (* Type : Ident '.' Name0 .*)
  587.   DEC (yyStackPtr, 3); yyNonterminal := 64;
  588. (* line 334 "Parser.lalr" *)
  589.    yySynAttribute.Type.Tree := mType (yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident, yyAttributeStack^[yyStackPtr+1].Scan.Position, mName (yyAttributeStack^[yyStackPtr+3].Name0.Id, yyAttributeStack^[yyStackPtr+3].Name0.Position, nNoName));
  590.    ;
  591.   
  592.   | 280,172: (* Type : '[' Names ']' .*)
  593.   DEC (yyStackPtr, 3); yyNonterminal := 64;
  594. (* line 337 "Parser.lalr" *)
  595.    yySynAttribute.Type.Tree := mType (NoIdent, yyAttributeStack^[yyStackPtr+1].Scan.Position, ReverseTree (yyAttributeStack^[yyStackPtr+2].Names.Tree));
  596.    ;
  597.   
  598.   | 281,171: (* Type : Ident '.' '[' Names ']' .*)
  599.   DEC (yyStackPtr, 5); yyNonterminal := 64;
  600. (* line 340 "Parser.lalr" *)
  601.    yySynAttribute.Type.Tree := mType (yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident, yyAttributeStack^[yyStackPtr+1].Scan.Position, ReverseTree (yyAttributeStack^[yyStackPtr+4].Names.Tree));
  602.    ;
  603.   
  604.   | 282: (* LocalCode : .*)
  605.   DEC (yyStackPtr, 0); yyNonterminal := 62;
  606. (* line 343 "Parser.lalr" *)
  607.    MakeText (yySynAttribute.LocalCode.Text); ;
  608.    yySynAttribute.LocalCode.Position := NoPosition;
  609.    ;
  610.   
  611.   | 283,174: (* LocalCode : 'LOCAL' TargetBlock .*)
  612.   DEC (yyStackPtr, 2); yyNonterminal := 62;
  613. (* line 347 "Parser.lalr" *)
  614.   yySynAttribute.LocalCode.Position := yyAttributeStack^[yyStackPtr+2].Scan.Position;
  615.   yySynAttribute.LocalCode.Text := yyAttributeStack^[yyStackPtr+2].Scan.TargetBlock.Text;
  616.   
  617.   | 284: (* Rules : .*)
  618.   DEC (yyStackPtr, 0); yyNonterminal := 63;
  619. (* line 350 "Parser.lalr" *)
  620.    yySynAttribute.Rules.Tree := nNoRule;
  621.    ;
  622.   
  623.   | 285,197: (* Rules : Rules SetLine Patterns2 '.' .*)
  624.   DEC (yyStackPtr, 4); yyNonterminal := 63;
  625. (* line 353 "Parser.lalr" *)
  626.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns2.Tree, mNoExpr (yyAttributeStack^[yyStackPtr+4].Scan.Position),
  627.              mNoExpr (yyAttributeStack^[yyStackPtr+4].Scan.Position), nNoStatement, yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  628.    ;
  629.   
  630.   | 286,211: (* Rules : Rules SetLine Patterns '?' Statements '.' .*)
  631.   DEC (yyStackPtr, 6); yyNonterminal := 63;
  632. (* line 357 "Parser.lalr" *)
  633.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns.Tree, mNoExpr (yyAttributeStack^[yyStackPtr+6].Scan.Position),
  634.              mNoExpr (yyAttributeStack^[yyStackPtr+6].Scan.Position), ReverseTree (yyAttributeStack^[yyStackPtr+5].Statements.Tree), yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  635.    ;
  636.   
  637.   | 287,198: (* Rules : Rules SetLine Patterns '=>' Exprs2 '.' .*)
  638.   DEC (yyStackPtr, 6); yyNonterminal := 63;
  639. (* line 361 "Parser.lalr" *)
  640.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns.Tree, yyAttributeStack^[yyStackPtr+5].Exprs2.Tree, mNoExpr (yyAttributeStack^[yyStackPtr+6].Scan.Position),
  641.              nNoStatement, yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  642.    ;
  643.   
  644.   | 288,215: (* Rules : Rules SetLine Patterns RETURN Expr ';' '.' .*)
  645.   DEC (yyStackPtr, 7); yyNonterminal := 63;
  646. (* line 365 "Parser.lalr" *)
  647.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns.Tree, mNoExpr (yyAttributeStack^[yyStackPtr+7].Scan.Position), yyAttributeStack^[yyStackPtr+5].Expr.Tree,
  648.              nNoStatement, yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  649.    ;
  650.   
  651.   | 289,200: (* Rules : Rules SetLine Patterns '=>' Exprs '?' Statements '.' .*)
  652.   DEC (yyStackPtr, 8); yyNonterminal := 63;
  653. (* line 369 "Parser.lalr" *)
  654.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns.Tree, yyAttributeStack^[yyStackPtr+5].Exprs.Tree, mNoExpr (yyAttributeStack^[yyStackPtr+8].Scan.Position),
  655.              ReverseTree (yyAttributeStack^[yyStackPtr+7].Statements.Tree), yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  656.    ;
  657.   
  658.   | 290,212: (* Rules : Rules SetLine Patterns '?' Statements '=>' Exprs2 '.' .*)
  659.   DEC (yyStackPtr, 8); yyNonterminal := 63;
  660. (* line 373 "Parser.lalr" *)
  661.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns.Tree, yyAttributeStack^[yyStackPtr+7].Exprs2.Tree, mNoExpr (yyAttributeStack^[yyStackPtr+8].Scan.Position),
  662.              ReverseTree (yyAttributeStack^[yyStackPtr+5].Statements.Tree), yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  663.    ;
  664.   
  665.   | 291,209: (* Rules : Rules SetLine Patterns '=>' Exprs RETURN Expr ';' '.' .*)
  666.   DEC (yyStackPtr, 9); yyNonterminal := 63;
  667. (* line 377 "Parser.lalr" *)
  668.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns.Tree, yyAttributeStack^[yyStackPtr+5].Exprs.Tree, yyAttributeStack^[yyStackPtr+7].Expr.Tree,
  669.              nNoStatement, yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  670.    ;
  671.   
  672.   | 292,216: (* Rules : Rules SetLine Patterns RETURN Expr OptSemiColon '?' Statements '.' .*)
  673.   DEC (yyStackPtr, 9); yyNonterminal := 63;
  674. (* line 381 "Parser.lalr" *)
  675.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns.Tree, mNoExpr (yyAttributeStack^[yyStackPtr+9].Scan.Position), yyAttributeStack^[yyStackPtr+5].Expr.Tree,
  676.              ReverseTree (yyAttributeStack^[yyStackPtr+8].Statements.Tree), yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  677.    ;
  678.   
  679.   | 293,214: (* Rules : Rules SetLine Patterns '?' Statements RETURN Expr ';' '.' .*)
  680.   DEC (yyStackPtr, 9); yyNonterminal := 63;
  681. (* line 385 "Parser.lalr" *)
  682.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns.Tree, mNoExpr (yyAttributeStack^[yyStackPtr+9].Scan.Position), yyAttributeStack^[yyStackPtr+7].Expr.Tree,
  683.              ReverseTree (yyAttributeStack^[yyStackPtr+5].Statements.Tree), yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  684.    ;
  685.   
  686.   | 294,210: (* Rules : Rules SetLine Patterns '=>' Exprs RETURN Expr OptSemiColon '?' Statements '.' .*)
  687.   DEC (yyStackPtr, 11); yyNonterminal := 63;
  688. (* line 389 "Parser.lalr" *)
  689.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns.Tree, yyAttributeStack^[yyStackPtr+5].Exprs.Tree, yyAttributeStack^[yyStackPtr+7].Expr.Tree,
  690.              ReverseTree (yyAttributeStack^[yyStackPtr+10].Statements.Tree), yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  691.    ;
  692.   
  693.   | 295,205: (* Rules : Rules SetLine Patterns '=>' Exprs '?' Statements RETURN Expr ';' '.' .*)
  694.   DEC (yyStackPtr, 11); yyNonterminal := 63;
  695. (* line 393 "Parser.lalr" *)
  696.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns.Tree, yyAttributeStack^[yyStackPtr+5].Exprs.Tree, yyAttributeStack^[yyStackPtr+9].Expr.Tree,
  697.              ReverseTree (yyAttributeStack^[yyStackPtr+7].Statements.Tree), yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  698.    ;
  699.   
  700.   | 296,213: (* Rules : Rules SetLine Patterns '?' Statements '=>' Exprs RETURN Expr ';' '.' .*)
  701.   DEC (yyStackPtr, 11); yyNonterminal := 63;
  702. (* line 397 "Parser.lalr" *)
  703.    yySynAttribute.Rules.Tree := mRules (Line, yyAttributeStack^[yyStackPtr+3].Patterns.Tree, yyAttributeStack^[yyStackPtr+7].Exprs.Tree, yyAttributeStack^[yyStackPtr+9].Expr.Tree,
  704.              ReverseTree (yyAttributeStack^[yyStackPtr+5].Statements.Tree), yyAttributeStack^[yyStackPtr+1].Rules.Tree);
  705.    ;
  706.   
  707.   | 297: (* SetLine : .*)
  708.   DEC (yyStackPtr, 0); yyNonterminal := 67;
  709. (* line 401 "Parser.lalr" *)
  710.    ;
  711.    Line := Attribute.Position; ;
  712.    ;
  713.   
  714.   | 298: (* OptSemiColon : .*)
  715.   DEC (yyStackPtr, 0); yyNonterminal := 58;
  716.  
  717.   | 299,164: (* OptSemiColon : ';' .*)
  718.   DEC (yyStackPtr, 1); yyNonterminal := 58;
  719.  
  720.   | 300: (* Patterns : Exprs .*)
  721.   DEC (yyStackPtr, 1); yyNonterminal := 69;
  722. (* line 407 "Parser.lalr" *)
  723.    yySynAttribute.Patterns.Tree := mOnePatternsList (yyAttributeStack^[yyStackPtr+1].Exprs.Tree, nNoPatternsList);
  724.    ;
  725.   
  726.   | 301,238: (* Patterns : Exprs ';' Patterns .*)
  727.   DEC (yyStackPtr, 3); yyNonterminal := 69;
  728. (* line 410 "Parser.lalr" *)
  729.    yySynAttribute.Patterns.Tree := mOnePatternsList (yyAttributeStack^[yyStackPtr+1].Exprs.Tree, yyAttributeStack^[yyStackPtr+3].Patterns.Tree);
  730.    ;
  731.   
  732.   | 302: (* Patterns2 : Exprs ';' .*)
  733.   DEC (yyStackPtr, 2); yyNonterminal := 68;
  734. (* line 413 "Parser.lalr" *)
  735.    yySynAttribute.Patterns2.Tree := mOnePatternsList (yyAttributeStack^[yyStackPtr+1].Exprs.Tree, nNoPatternsList);
  736.    ;
  737.   
  738.   | 303,237: (* Patterns2 : Exprs ';' Patterns2 .*)
  739.   DEC (yyStackPtr, 3); yyNonterminal := 68;
  740. (* line 416 "Parser.lalr" *)
  741.    yySynAttribute.Patterns2.Tree := mOnePatternsList (yyAttributeStack^[yyStackPtr+1].Exprs.Tree, yyAttributeStack^[yyStackPtr+3].Patterns2.Tree);
  742.    ;
  743.   
  744.   | 304: (* Exprs : '..' .*)
  745.   DEC (yyStackPtr, 1); yyNonterminal := 73;
  746. (* line 419 "Parser.lalr" *)
  747.    yySynAttribute.Exprs.Tree := mOneExpr (mDontCare (yyAttributeStack^[yyStackPtr+1].Scan.Position), mNoExpr (Attribute.Position));
  748.    ;
  749.   
  750.   | 305,190: (* Exprs : '..' ',' .*)
  751.   DEC (yyStackPtr, 2); yyNonterminal := 73;
  752. (* line 422 "Parser.lalr" *)
  753.    yySynAttribute.Exprs.Tree := mOneExpr (mDontCare (yyAttributeStack^[yyStackPtr+1].Scan.Position), mNoExpr (Attribute.Position));
  754.    ;
  755.   
  756.   | 306: (* Exprs : Expr .*)
  757.   DEC (yyStackPtr, 1); yyNonterminal := 73;
  758. (* line 425 "Parser.lalr" *)
  759.    yySynAttribute.Exprs.Tree := mOneExpr (yyAttributeStack^[yyStackPtr+1].Expr.Tree, mNoExpr (Attribute.Position));
  760.    ;
  761.   
  762.   | 307,228: (* Exprs : Expr ',' Exprs .*)
  763.   DEC (yyStackPtr, 3); yyNonterminal := 73;
  764. (* line 428 "Parser.lalr" *)
  765.    yySynAttribute.Exprs.Tree := mOneExpr (yyAttributeStack^[yyStackPtr+1].Expr.Tree, yyAttributeStack^[yyStackPtr+3].Exprs.Tree);
  766.    ;
  767.   
  768.   | 308,229: (* Exprs : NamedExprs .*)
  769.   DEC (yyStackPtr, 1); yyNonterminal := 73;
  770. (* line 431 "Parser.lalr" *)
  771.   yySynAttribute.Exprs.Tree := yyAttributeStack^[yyStackPtr+1].NamedExprs.Tree;
  772.   
  773.   | 309: (* NamedExprs : .*)
  774.   DEC (yyStackPtr, 0); yyNonterminal := 74;
  775. (* line 433 "Parser.lalr" *)
  776.    yySynAttribute.NamedExprs.Tree := mNoExpr (Attribute.Position);
  777.    ;
  778.   
  779.   | 310: (* NamedExprs : Ident ':=' Expr .*)
  780.   DEC (yyStackPtr, 3); yyNonterminal := 74;
  781. (* line 436 "Parser.lalr" *)
  782.    yySynAttribute.NamedExprs.Tree := mNamedExpr (yyAttributeStack^[yyStackPtr+3].Expr.Tree, mNoExpr (Attribute.Position), yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident);
  783.    ;
  784.   
  785.   | 311,232: (* NamedExprs : Ident ':=' Expr ',' NamedExprs .*)
  786.   DEC (yyStackPtr, 5); yyNonterminal := 74;
  787. (* line 439 "Parser.lalr" *)
  788.    yySynAttribute.NamedExprs.Tree := mNamedExpr (yyAttributeStack^[yyStackPtr+3].Expr.Tree, yyAttributeStack^[yyStackPtr+5].NamedExprs.Tree, yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident);
  789.    ;
  790.   
  791.   | 312: (* Exprs2 : '..' .*)
  792.   DEC (yyStackPtr, 1); yyNonterminal := 71;
  793. (* line 442 "Parser.lalr" *)
  794.    yySynAttribute.Exprs2.Tree := mOneExpr (mDontCare (yyAttributeStack^[yyStackPtr+1].Scan.Position), mNoExpr (Attribute.Position));
  795.    ;
  796.   
  797.   | 313: (* Exprs2 : '..' ',' .*)
  798.   DEC (yyStackPtr, 2); yyNonterminal := 71;
  799. (* line 445 "Parser.lalr" *)
  800.    yySynAttribute.Exprs2.Tree := mOneExpr (mDontCare (yyAttributeStack^[yyStackPtr+1].Scan.Position), mNoExpr (Attribute.Position));
  801.    ;
  802.   
  803.   | 314,234: (* Exprs2 : Expr ',' Exprs2 .*)
  804.   DEC (yyStackPtr, 3); yyNonterminal := 71;
  805. (* line 448 "Parser.lalr" *)
  806.    yySynAttribute.Exprs2.Tree := mOneExpr (yyAttributeStack^[yyStackPtr+1].Expr.Tree, yyAttributeStack^[yyStackPtr+3].Exprs2.Tree);
  807.    ;
  808.   
  809.   | 315,235: (* Exprs2 : NamedExprs2 .*)
  810.   DEC (yyStackPtr, 1); yyNonterminal := 71;
  811. (* line 451 "Parser.lalr" *)
  812.   yySynAttribute.Exprs2.Tree := yyAttributeStack^[yyStackPtr+1].NamedExprs2.Tree;
  813.   
  814.   | 316: (* NamedExprs2 : .*)
  815.   DEC (yyStackPtr, 0); yyNonterminal := 75;
  816. (* line 453 "Parser.lalr" *)
  817.    yySynAttribute.NamedExprs2.Tree := mNoExpr (Attribute.Position);
  818.    ;
  819.   
  820.   | 317,233: (* NamedExprs2 : Ident ':=' Expr ',' NamedExprs2 .*)
  821.   DEC (yyStackPtr, 5); yyNonterminal := 75;
  822. (* line 456 "Parser.lalr" *)
  823.    yySynAttribute.NamedExprs2.Tree := mNamedExpr (yyAttributeStack^[yyStackPtr+3].Expr.Tree, yyAttributeStack^[yyStackPtr+5].NamedExprs2.Tree, yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident);
  824.    ;
  825.   
  826.   | 318,230: (* Expr : PrefixExpr .*)
  827.   DEC (yyStackPtr, 1); yyNonterminal := 72;
  828. (* line 459 "Parser.lalr" *)
  829.   yySynAttribute.Expr.Tree := yyAttributeStack^[yyStackPtr+1].PrefixExpr.Tree;
  830.   
  831.   | 319,226: (* Expr : Expr Operator PrefixExpr .*)
  832.   DEC (yyStackPtr, 3); yyNonterminal := 72;
  833. (* line 461 "Parser.lalr" *)
  834.    yySynAttribute.Expr.Tree := mBinary (yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+1].Expr.Tree, yyAttributeStack^[yyStackPtr+2].Scan.Operator.Ident, yyAttributeStack^[yyStackPtr+3].PrefixExpr.Tree);
  835.    ;
  836.   
  837.   | 320: (* PrefixExpr : PostfixExpr .*)
  838.   DEC (yyStackPtr, 1); yyNonterminal := 76;
  839. (* line 464 "Parser.lalr" *)
  840.   yySynAttribute.PrefixExpr.Tree := yyAttributeStack^[yyStackPtr+1].PostfixExpr.Tree;
  841.   
  842.   | 321: (* PrefixExpr : Ident ':' PostfixExpr .*)
  843.   DEC (yyStackPtr, 3); yyNonterminal := 76;
  844. (* line 477 "Parser.lalr" *)
  845.   
  846.           yySynAttribute.PrefixExpr.Tree := yyAttributeStack^[yyStackPtr+3].PostfixExpr.Tree;
  847.           IF yySynAttribute.PrefixExpr.Tree^.Kind = Compose THEN
  848.              yySynAttribute.PrefixExpr.Tree^.Compose.Selector := yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident;
  849.           ELSIF yySynAttribute.PrefixExpr.Tree^.Kind = Nil THEN
  850.              yySynAttribute.PrefixExpr.Tree^.Nil.Selector := yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident;
  851.           ELSIF yySynAttribute.PrefixExpr.Tree^.Kind = VarUse THEN
  852.              yySynAttribute.PrefixExpr.Tree := mCompose (yySynAttribute.PrefixExpr.Tree^.VarUse.Pos, yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident, yySynAttribute.PrefixExpr.Tree,
  853.                  mOneExpr (mDontCare (yySynAttribute.PrefixExpr.Tree^.VarUse.Pos),
  854.                  mNoExpr (yySynAttribute.PrefixExpr.Tree^.VarUse.Pos)), FALSE);
  855.           ELSE
  856.              Warning ("label ignored", yyAttributeStack^[yyStackPtr+1].Scan.Position);
  857.           END; ;
  858.    ;
  859.   
  860.   | 322: (* PrefixExpr : Ident ':>' PostfixExpr .*)
  861.   DEC (yyStackPtr, 3); yyNonterminal := 76;
  862. (* line 493 "Parser.lalr" *)
  863.   
  864.           yySynAttribute.PrefixExpr.Tree := yyAttributeStack^[yyStackPtr+3].PostfixExpr.Tree;
  865.           IF yySynAttribute.PrefixExpr.Tree^.Kind = Compose THEN
  866.              yySynAttribute.PrefixExpr.Tree^.Compose.Selector := yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident;
  867.              yySynAttribute.PrefixExpr.Tree^.Compose.Widen := TRUE;
  868.           ELSIF yySynAttribute.PrefixExpr.Tree^.Kind = Nil THEN
  869.              yySynAttribute.PrefixExpr.Tree^.Nil.Selector := yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident;
  870.           ELSIF yySynAttribute.PrefixExpr.Tree^.Kind = VarUse THEN
  871.              yySynAttribute.PrefixExpr.Tree := mCompose (yySynAttribute.PrefixExpr.Tree^.VarUse.Pos, yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident, yySynAttribute.PrefixExpr.Tree,
  872.                  mOneExpr (mDontCare (yySynAttribute.PrefixExpr.Tree^.VarUse.Pos),
  873.                  mNoExpr (yySynAttribute.PrefixExpr.Tree^.VarUse.Pos)), TRUE);
  874.           ELSE
  875.              Warning ("label ignored", yyAttributeStack^[yyStackPtr+1].Scan.Position);
  876.           END; ;
  877.    ;
  878.   
  879.   | 323,231: (* PrefixExpr : Operator PrefixExpr .*)
  880.   DEC (yyStackPtr, 2); yyNonterminal := 76;
  881. (* line 497 "Parser.lalr" *)
  882.    yySynAttribute.PrefixExpr.Tree := mPreOperator (yyAttributeStack^[yyStackPtr+1].Scan.Position, yyAttributeStack^[yyStackPtr+1].Scan.Operator.Ident, yyAttributeStack^[yyStackPtr+2].PrefixExpr.Tree);
  883.    ;
  884.   
  885.   | 324,225: (* PrefixExpr : IncOperator PrefixExpr .*)
  886.   DEC (yyStackPtr, 2); yyNonterminal := 76;
  887. (* line 500 "Parser.lalr" *)
  888.    yySynAttribute.PrefixExpr.Tree := mPreOperator (yyAttributeStack^[yyStackPtr+1].Scan.Position, yyAttributeStack^[yyStackPtr+1].Scan.IncOperator.Ident, yyAttributeStack^[yyStackPtr+2].PrefixExpr.Tree);
  889.    ;
  890.   
  891.   | 325,227: (* PostfixExpr : PrimaryExpr .*)
  892.   DEC (yyStackPtr, 1); yyNonterminal := 77;
  893. (* line 503 "Parser.lalr" *)
  894.   yySynAttribute.PostfixExpr.Tree := yyAttributeStack^[yyStackPtr+1].PrimaryExpr.Tree;
  895.   
  896.   | 326,191: (* PostfixExpr : PostfixExpr '[' Exprs ']' .*)
  897.   DEC (yyStackPtr, 4); yyNonterminal := 77;
  898. (* line 505 "Parser.lalr" *)
  899.    yySynAttribute.PostfixExpr.Tree := mIndex (yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+1].PostfixExpr.Tree, yyAttributeStack^[yyStackPtr+3].Exprs.Tree);
  900.    ;
  901.   
  902.   | 327,195: (* PostfixExpr : PostfixExpr '(' Exprs ')' .*)
  903.   DEC (yyStackPtr, 4); yyNonterminal := 77;
  904. (* line 508 "Parser.lalr" *)
  905.    yySynAttribute.PostfixExpr.Tree := mCompose (yyAttributeStack^[yyStackPtr+2].Scan.Position, NoIdent, yyAttributeStack^[yyStackPtr+1].PostfixExpr.Tree, yyAttributeStack^[yyStackPtr+3].Exprs.Tree, FALSE);
  906.    ;
  907.   
  908.   | 328,194: (* PostfixExpr : PostfixExpr '(' Exprs '=>' Exprs ')' .*)
  909.   DEC (yyStackPtr, 6); yyNonterminal := 77;
  910. (* line 511 "Parser.lalr" *)
  911.    yySynAttribute.PostfixExpr.Tree := mCall (yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+1].PostfixExpr.Tree, yyAttributeStack^[yyStackPtr+3].Exprs.Tree, yyAttributeStack^[yyStackPtr+5].Exprs.Tree);
  912.    ;
  913.   
  914.   | 329,189: (* PostfixExpr : PostfixExpr '.' Ident .*)
  915.   DEC (yyStackPtr, 3); yyNonterminal := 77;
  916. (* line 514 "Parser.lalr" *)
  917.    ArrayToString (".", String1);
  918.           yySynAttribute.PostfixExpr.Tree := mBinary (yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+1].PostfixExpr.Tree, MakeIdent (String1),
  919.                 mVarUse (yyAttributeStack^[yyStackPtr+3].Scan.Position, yyAttributeStack^[yyStackPtr+3].Scan.Ident.Ident)); ;
  920.    ;
  921.   
  922.   | 330,192: (* PostfixExpr : PostfixExpr '->' Ident .*)
  923.   DEC (yyStackPtr, 3); yyNonterminal := 77;
  924. (* line 519 "Parser.lalr" *)
  925.    ArrayToString ("->", String1);
  926.           yySynAttribute.PostfixExpr.Tree := mBinary (yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+1].PostfixExpr.Tree, MakeIdent (String1),
  927.                 mVarUse (yyAttributeStack^[yyStackPtr+3].Scan.Position, yyAttributeStack^[yyStackPtr+3].Scan.Ident.Ident)); ;
  928.    ;
  929.   
  930.   | 331,193: (* PostfixExpr : PostfixExpr '^' .*)
  931.   DEC (yyStackPtr, 2); yyNonterminal := 77;
  932. (* line 524 "Parser.lalr" *)
  933.    ArrayToString ("^", String1);
  934.           yySynAttribute.PostfixExpr.Tree := mPostOperator (yyAttributeStack^[yyStackPtr+2].Scan.Position, MakeIdent (String1), yyAttributeStack^[yyStackPtr+1].PostfixExpr.Tree); ;
  935.    ;
  936.   
  937.   | 332,188: (* PostfixExpr : PostfixExpr IncOperator .*)
  938.   DEC (yyStackPtr, 2); yyNonterminal := 77;
  939. (* line 528 "Parser.lalr" *)
  940.    yySynAttribute.PostfixExpr.Tree := mPostOperator (yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+2].Scan.IncOperator.Ident, yyAttributeStack^[yyStackPtr+1].PostfixExpr.Tree);
  941.    ;
  942.   
  943.   | 333: (* PrimaryExpr : Ident .*)
  944.   DEC (yyStackPtr, 1); yyNonterminal := 78;
  945. (* line 531 "Parser.lalr" *)
  946.    yySynAttribute.PrimaryExpr.Tree := mVarUse (yyAttributeStack^[yyStackPtr+1].Scan.Position, yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident);
  947.    ;
  948.   
  949.   | 334,178: (* PrimaryExpr : NIL .*)
  950.   DEC (yyStackPtr, 1); yyNonterminal := 78;
  951. (* line 534 "Parser.lalr" *)
  952.    yySynAttribute.PrimaryExpr.Tree := mNil (yyAttributeStack^[yyStackPtr+1].Scan.Position, NoIdent);
  953.    ;
  954.   
  955.   | 335,179: (* PrimaryExpr : '_' .*)
  956.   DEC (yyStackPtr, 1); yyNonterminal := 78;
  957. (* line 537 "Parser.lalr" *)
  958.    yySynAttribute.PrimaryExpr.Tree := mDontCare1 (yyAttributeStack^[yyStackPtr+1].Scan.Position);
  959.    ;
  960.   
  961.   | 336,177: (* PrimaryExpr : Number .*)
  962.   DEC (yyStackPtr, 1); yyNonterminal := 78;
  963. (* line 540 "Parser.lalr" *)
  964.    yySynAttribute.PrimaryExpr.Tree := mTargetExpr (yyAttributeStack^[yyStackPtr+1].Scan.Position, mAny (yyAttributeStack^[yyStackPtr+1].Scan.Number.StringRef, nNoDesignator));
  965.    ;
  966.   
  967.   | 337,176: (* PrimaryExpr : String .*)
  968.   DEC (yyStackPtr, 1); yyNonterminal := 78;
  969. (* line 543 "Parser.lalr" *)
  970.    yySynAttribute.PrimaryExpr.Tree := mStringExpr (yyAttributeStack^[yyStackPtr+1].Scan.Position, yyAttributeStack^[yyStackPtr+1].Scan.String.StringRef);
  971.    ;
  972.   
  973.   | 338,175: (* PrimaryExpr : Ident '::' Ident .*)
  974.   DEC (yyStackPtr, 3); yyNonterminal := 78;
  975. (* line 546 "Parser.lalr" *)
  976.    yySynAttribute.PrimaryExpr.Tree := mAttrDesc (yyAttributeStack^[yyStackPtr+3].Scan.Position, yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident, yyAttributeStack^[yyStackPtr+3].Scan.Ident.Ident);
  977.    ;
  978.   
  979.   | 339,185: (* PrimaryExpr : '{' TargetCodes '}' .*)
  980.   DEC (yyStackPtr, 3); yyNonterminal := 78;
  981. (* line 549 "Parser.lalr" *)
  982.    yySynAttribute.PrimaryExpr.Tree := mTargetExpr (yyAttributeStack^[yyStackPtr+1].Scan.Position, ReverseTree (yyAttributeStack^[yyStackPtr+2].TargetCodes.Tree));
  983.    ;
  984.   
  985.   | 340,196: (* PrimaryExpr : '(' Expr ')' .*)
  986.   DEC (yyStackPtr, 3); yyNonterminal := 78;
  987. (* line 552 "Parser.lalr" *)
  988.    yySynAttribute.PrimaryExpr.Tree := mParents (yyAttributeStack^[yyStackPtr+1].Scan.Position, yyAttributeStack^[yyStackPtr+2].Expr.Tree);
  989.    ;
  990.   
  991.   | 341: (* Statements : .*)
  992.   DEC (yyStackPtr, 0); yyNonterminal := 70;
  993. (* line 555 "Parser.lalr" *)
  994.    yySynAttribute.Statements.Tree := nNoStatement;
  995.    ;
  996.   
  997.   | 342,207: (* Statements : Statements Expr ';' .*)
  998.   DEC (yyStackPtr, 3); yyNonterminal := 70;
  999. (* line 558 "Parser.lalr" *)
  1000.    yySynAttribute.Statements.Tree := mProcCall (yyAttributeStack^[yyStackPtr+2].Expr.Tree^.Expr.Pos, yyAttributeStack^[yyStackPtr+1].Statements.Tree, yyAttributeStack^[yyStackPtr+2].Expr.Tree);
  1001.    ;
  1002.   
  1003.   | 343,208: (* Statements : Statements Expr ':=' Expr ';' .*)
  1004.   DEC (yyStackPtr, 5); yyNonterminal := 70;
  1005. (* line 561 "Parser.lalr" *)
  1006.    yySynAttribute.Statements.Tree := mAssignment (yyAttributeStack^[yyStackPtr+3].Scan.Position, yyAttributeStack^[yyStackPtr+1].Statements.Tree, yyAttributeStack^[yyStackPtr+2].Expr.Tree, yyAttributeStack^[yyStackPtr+4].Expr.Tree);
  1007.    ;
  1008.   
  1009.   | 344,202: (* Statements : Statements REJECT .*)
  1010.   DEC (yyStackPtr, 2); yyNonterminal := 70;
  1011. (* line 564 "Parser.lalr" *)
  1012.    yySynAttribute.Statements.Tree := mReject (yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+1].Statements.Tree);
  1013.    ;
  1014.   
  1015.   | 345,203: (* Statements : Statements FAIL .*)
  1016.   DEC (yyStackPtr, 2); yyNonterminal := 70;
  1017. (* line 567 "Parser.lalr" *)
  1018.    yySynAttribute.Statements.Tree := mFail (yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+1].Statements.Tree);
  1019.    ;
  1020.   
  1021.   | 346,206: (* Statements : Statements Declarations ';' .*)
  1022.   DEC (yyStackPtr, 3); yyNonterminal := 70;
  1023. (* line 570 "Parser.lalr" *)
  1024.    yySynAttribute.Statements.Tree := mTargetStmt (yyAttributeStack^[yyStackPtr+3].Scan.Position, yyAttributeStack^[yyStackPtr+1].Statements.Tree, yyAttributeStack^[yyStackPtr+2].Declarations.Tree, nNoDesignator);
  1025.    ;
  1026.   
  1027.   | 347,201: (* Statements : Statements '{' TargetCodes '}' ';' .*)
  1028.   DEC (yyStackPtr, 5); yyNonterminal := 70;
  1029. (* line 573 "Parser.lalr" *)
  1030.    yySynAttribute.Statements.Tree := mTargetStmt (yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+1].Statements.Tree, nNoParameter, ReverseTree (yyAttributeStack^[yyStackPtr+3].TargetCodes.Tree));
  1031.    ;
  1032.   
  1033.   | 348,204: (* Statements : Statements NL .*)
  1034.   DEC (yyStackPtr, 2); yyNonterminal := 70;
  1035. (* line 576 "Parser.lalr" *)
  1036.    yySynAttribute.Statements.Tree := mNl (yyAttributeStack^[yyStackPtr+2].Scan.Position, yyAttributeStack^[yyStackPtr+1].Statements.Tree);
  1037.    ;
  1038.   
  1039.   | 349,199: (* Statements : Statements ';' .*)
  1040.   DEC (yyStackPtr, 2); yyNonterminal := 70;
  1041. (* line 579 "Parser.lalr" *)
  1042.   yySynAttribute.Statements.Tree := yyAttributeStack^[yyStackPtr+1].Statements.Tree;
  1043.   
  1044.   | 350: (* TargetCodes : .*)
  1045.   DEC (yyStackPtr, 0); yyNonterminal := 79;
  1046. (* line 581 "Parser.lalr" *)
  1047.    yySynAttribute.TargetCodes.Tree := nNoDesignator;
  1048.    ;
  1049.   
  1050.   | 351,187: (* TargetCodes : TargetCodes Name1 Space '::' Space Ident .*)
  1051.   DEC (yyStackPtr, 6); yyNonterminal := 79;
  1052. (* line 584 "Parser.lalr" *)
  1053.    yySynAttribute.TargetCodes.Tree := mDesignator (yyAttributeStack^[yyStackPtr+2].Name1.Id, yyAttributeStack^[yyStackPtr+6].Scan.Ident.Ident, yyAttributeStack^[yyStackPtr+2].Name1.Position, yyAttributeStack^[yyStackPtr+1].TargetCodes.Tree);
  1054.    ;
  1055.   
  1056.   | 352: (* TargetCodes : TargetCodes Name1 Space '::' Space .*)
  1057.   DEC (yyStackPtr, 5); yyNonterminal := 79;
  1058. (* line 587 "Parser.lalr" *)
  1059.   
  1060.           yySynAttribute.TargetCodes.Tree := mIdent (yyAttributeStack^[yyStackPtr+2].Name1.Id, yyAttributeStack^[yyStackPtr+2].Name1.Position, yyAttributeStack^[yyStackPtr+1].TargetCodes.Tree);
  1061.           yySynAttribute.TargetCodes.Tree := mAnys (ReverseTree (yyAttributeStack^[yyStackPtr+3].Space.Tree), yySynAttribute.TargetCodes.Tree);
  1062.           yySynAttribute.TargetCodes.Tree := mAny (yyAttributeStack^[yyStackPtr+4].Scan.yy9.StringRef, yySynAttribute.TargetCodes.Tree);
  1063.           yySynAttribute.TargetCodes.Tree := mAnys (ReverseTree (yyAttributeStack^[yyStackPtr+5].Space.Tree), yySynAttribute.TargetCodes.Tree); ;
  1064.    ;
  1065.   
  1066.   | 353: (* TargetCodes : TargetCodes Name1 Space .*)
  1067.   DEC (yyStackPtr, 3); yyNonterminal := 79;
  1068. (* line 594 "Parser.lalr" *)
  1069.   
  1070.           yySynAttribute.TargetCodes.Tree := mIdent (yyAttributeStack^[yyStackPtr+2].Name1.Id, yyAttributeStack^[yyStackPtr+2].Name1.Position, yyAttributeStack^[yyStackPtr+1].TargetCodes.Tree);
  1071.           yySynAttribute.TargetCodes.Tree := mAnys (ReverseTree (yyAttributeStack^[yyStackPtr+3].Space.Tree), yySynAttribute.TargetCodes.Tree); ;
  1072.    ;
  1073.   
  1074.   | 354,184: (* TargetCodes : TargetCodes '::' .*)
  1075.   DEC (yyStackPtr, 2); yyNonterminal := 79;
  1076. (* line 599 "Parser.lalr" *)
  1077.    yySynAttribute.TargetCodes.Tree := mAny (yyAttributeStack^[yyStackPtr+2].Scan.yy9.StringRef, yyAttributeStack^[yyStackPtr+1].TargetCodes.Tree);
  1078.    ;
  1079.   
  1080.   | 355,182: (* TargetCodes : TargetCodes TargetCode .*)
  1081.   DEC (yyStackPtr, 2); yyNonterminal := 79;
  1082. (* line 602 "Parser.lalr" *)
  1083.    yySynAttribute.TargetCodes.Tree := mAny (yyAttributeStack^[yyStackPtr+2].Scan.TargetCode.StringRef, yyAttributeStack^[yyStackPtr+1].TargetCodes.Tree);
  1084.    ;
  1085.   
  1086.   | 356,183: (* TargetCodes : TargetCodes WhiteSpace .*)
  1087.   DEC (yyStackPtr, 2); yyNonterminal := 79;
  1088. (* line 605 "Parser.lalr" *)
  1089.    yySynAttribute.TargetCodes.Tree := mAny (yyAttributeStack^[yyStackPtr+2].Scan.WhiteSpace.StringRef, yyAttributeStack^[yyStackPtr+1].TargetCodes.Tree);
  1090.    ;
  1091.   
  1092.   | 357,160: (* Name0 : Ident .*)
  1093.   DEC (yyStackPtr, 1); yyNonterminal := 55;
  1094. (* line 608 "Parser.lalr" *)
  1095.    yySynAttribute.Name0.Id         :=  yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident;
  1096.   
  1097.           yySynAttribute.Name0.Position     :=  yyAttributeStack^[yyStackPtr+1].Scan.Position;
  1098.    ;
  1099.   
  1100.   | 358,161: (* Name0 : String .*)
  1101.   DEC (yyStackPtr, 1); yyNonterminal := 55;
  1102. (* line 613 "Parser.lalr" *)
  1103.    GetString (yyAttributeStack^[yyStackPtr+1].Scan.String.StringRef, String1);
  1104.                    SubString (String1, 2, Length (String1) - 1, String2);
  1105.                    yySynAttribute.Name0.Id := MakeIdent (String2); ;
  1106.   
  1107.           yySynAttribute.Name0.Position     :=  yyAttributeStack^[yyStackPtr+1].Scan.Position;
  1108.    ;
  1109.   
  1110.   | 359,180: (* Name1 : Ident .*)
  1111.   DEC (yyStackPtr, 1); yyNonterminal := 80;
  1112. (* line 620 "Parser.lalr" *)
  1113.    yySynAttribute.Name1.Id     :=  yyAttributeStack^[yyStackPtr+1].Scan.Ident.Ident;
  1114.   
  1115.           yySynAttribute.Name1.Position     :=  yyAttributeStack^[yyStackPtr+1].Scan.Position;
  1116.    ;
  1117.   
  1118.   | 360,181: (* Name1 : String .*)
  1119.   DEC (yyStackPtr, 1); yyNonterminal := 80;
  1120. (* line 625 "Parser.lalr" *)
  1121.    GetString (yyAttributeStack^[yyStackPtr+1].Scan.String.StringRef, String1); yySynAttribute.Name1.Id := MakeIdent (String1); ;
  1122.   
  1123.           yySynAttribute.Name1.Position     :=  yyAttributeStack^[yyStackPtr+1].Scan.Position;
  1124.    ;
  1125.   
  1126.   | 361: (* Space : .*)
  1127.   DEC (yyStackPtr, 0); yyNonterminal := 81;
  1128. (* line 630 "Parser.lalr" *)
  1129.    yySynAttribute.Space.Tree := nNoLayout;
  1130.    ;
  1131.   
  1132.   | 362,186: (* Space : Space WhiteSpace .*)
  1133.   DEC (yyStackPtr, 2); yyNonterminal := 81;
  1134. (* line 633 "Parser.lalr" *)
  1135.    yySynAttribute.Space.Tree := mLayoutAny (yyAttributeStack^[yyStackPtr+2].Scan.WhiteSpace.StringRef, yyAttributeStack^[yyStackPtr+1].Space.Tree);
  1136.    ;
  1137.   
  1138. END;
  1139.            (* SPEC State := Next (Top (), Nonterminal); nonterminal transition *)
  1140.            yyNCombPtr := yyNCombTypePtr (LONGCARD (yyNBasePtr [yyStateStack^ [yyStackPtr]])
  1141.                 + yyNonterminal * SYSTEM.TSIZE (yyNCombType));
  1142.            yyState := yyNCombPtr^;
  1143.            INC (yyStackPtr);
  1144.            yyAttributeStack^ [yyStackPtr] := yySynAttribute;
  1145.            IF yyState < yyFirstFinalState THEN EXIT END; (* read nonterminal ? *)
  1146.         END;
  1147.  
  1148.      ELSE                        (* read *)
  1149.         INC (yyStackPtr);
  1150.         yyAttributeStack^ [yyStackPtr].Scan := Scanner.Attribute;
  1151.         yyTerminal := Scanner.GetToken ();
  1152.         yyIsRepairing := FALSE;
  1153.      END;
  1154.       END;
  1155.    END Parser;
  1156.  
  1157. PROCEDURE ErrorRecovery (
  1158.       VAR Terminal    : yySymbolRange    ;
  1159.       StateStack    : yyStackType    ;
  1160.       StackSize    : LONGINT    ;
  1161.       StackPtr    : LONGINT    );
  1162.    VAR
  1163.       TokensSkipped    : BOOLEAN;
  1164.       ContinueSet    : Sets.tSet;
  1165.       RestartSet    : Sets.tSet;
  1166.       Token        : yySymbolRange;
  1167.       TokenArray    : ARRAY [0..127] OF CHAR;
  1168.       TokenString    : Strings.tString;
  1169.       ContinueString    : Strings.tString;
  1170.    BEGIN
  1171.    (* 1. report the error *)
  1172.       Errors.ErrorMessage (Errors.SyntaxError, Errors.Error, Scanner.Attribute.Position);
  1173.  
  1174.    (* 2. report the set of expected terminal symbols *)
  1175.       Sets.MakeSet (ContinueSet, yyLastTerminal);
  1176.       ComputeContinuation (StateStack, StackSize, StackPtr, ContinueSet);
  1177.       Strings.AssignEmpty (ContinueString);
  1178.       FOR Token := Sets.Minimum (ContinueSet) TO Sets.Maximum (ContinueSet) DO
  1179.      IF Sets.IsElement (Token, ContinueSet) THEN
  1180.         TokenName (Token, TokenArray);
  1181.         Strings.ArrayToString (TokenArray, TokenString);
  1182.         IF (Strings.Length (ContinueString) + Strings.Length (TokenString) + 1 <= Strings.cMaxStrLength) THEN
  1183.            Strings.Concatenate (ContinueString, TokenString);
  1184.            Strings.Append (ContinueString, ' ');
  1185.         END;
  1186.      END;
  1187.       END;
  1188.       Errors.ErrorMessageI (Errors.ExpectedTokens, Errors.Information,
  1189.      Scanner.Attribute.Position, Errors.String, SYSTEM.ADR (ContinueString));
  1190.       Sets.ReleaseSet (ContinueSet);
  1191.  
  1192.    (* 3. compute the set of terminal symbols for restart of the parse *)
  1193.       Sets.MakeSet (RestartSet, yyLastTerminal);
  1194.       ComputeRestartPoints (StateStack, StackSize, StackPtr, RestartSet);
  1195.  
  1196.    (* 4. skip terminal symbols until a restart point is reached *)
  1197.       TokensSkipped := FALSE;
  1198.       WHILE NOT Sets.IsElement (Terminal, RestartSet) DO
  1199.      Terminal := Scanner.GetToken ();
  1200.      TokensSkipped := TRUE;
  1201.       END;
  1202.       Sets.ReleaseSet (RestartSet);
  1203.  
  1204.    (* 5. report the restart point *)
  1205.       IF TokensSkipped THEN
  1206.      Errors.ErrorMessage (Errors.RestartPoint, Errors.Information, Scanner.Attribute.Position);
  1207.       END;
  1208.    END ErrorRecovery;
  1209.  
  1210. (*
  1211.    compute the set of terminal symbols that can be accepted (read)
  1212.    in a given stack configuration (eventually after reduce actions)
  1213. *)
  1214.  
  1215. PROCEDURE ComputeContinuation (
  1216.       Stack        : yyStackType    ;
  1217.       StackSize    : LONGINT    ;
  1218.       StackPtr    : LONGINT    ;
  1219.       VAR ContinueSet    : Sets.tSet    );
  1220.    VAR Terminal        : yySymbolRange;
  1221.    BEGIN
  1222.       Sets.AssignEmpty (ContinueSet);
  1223.       FOR Terminal := yyFirstTerminal TO yyLastTerminal DO
  1224.      IF IsContinuation (Terminal, Stack, StackSize, StackPtr) THEN
  1225.         Sets.Include (ContinueSet, Terminal);
  1226.      END;
  1227.       END;
  1228.    END ComputeContinuation;
  1229.  
  1230. (*
  1231.    check whether a given terminal symbol can be accepted (read)
  1232.    in a certain stack configuration (eventually after reduce actions)
  1233. *)
  1234.  
  1235. PROCEDURE IsContinuation (
  1236.       Terminal        : yySymbolRange    ;
  1237.       ParseStack    : yyStackType    ;
  1238.       StackSize        : LONGINT    ;
  1239.       StackPtr        : LONGINT    ): BOOLEAN;
  1240.    VAR
  1241.       State        : LONGINT;
  1242.       Nonterminal    : yySymbolRange;
  1243.       Stack        : yyStackType;
  1244.    BEGIN
  1245.       DynArray.MakeArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  1246.       FOR State := 0 TO StackPtr DO
  1247.      Stack^ [State] := ParseStack^ [State];
  1248.       END;
  1249.       State := Stack^ [StackPtr];
  1250.       LOOP
  1251.      Stack^ [StackPtr] := State;
  1252.      State := Next (State, Terminal);
  1253.      IF State = yyNoState THEN
  1254.         DynArray.ReleaseArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  1255.         RETURN FALSE;
  1256.      END;
  1257.      IF State <= yyLastReadTermState THEN        (* read or read terminal reduce ? *)
  1258.         DynArray.ReleaseArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  1259.         RETURN TRUE;
  1260.      END;
  1261.  
  1262.      LOOP                        (* reduce *)
  1263.         IF State =    yyStopState THEN
  1264.            DynArray.ReleaseArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  1265.            RETURN TRUE;
  1266.         ELSE 
  1267.            DEC (StackPtr, yyLength [State]);
  1268.            Nonterminal := yyLeftHandSide [State];
  1269.         END;
  1270.  
  1271.         State := Next (Stack^ [StackPtr], Nonterminal);
  1272.         IF StackPtr >= StackSize THEN
  1273.            DynArray.ExtendArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  1274.         END;
  1275.         INC (StackPtr);
  1276.         IF State < yyFirstFinalState THEN EXIT; END; (* read nonterminal ? *)
  1277.         State := yyFinalToProd [State];        (* read nonterminal reduce *)
  1278.      END;
  1279.       END;
  1280.    END IsContinuation;
  1281.  
  1282. (*
  1283.    compute a set of terminal symbols that can be used to restart
  1284.    parsing in a given stack configuration. we simulate parsing until
  1285.    end of file using a suffix program synthesized by the function
  1286.    Continuation. All symbols acceptable in the states reached during
  1287.    the simulation can be used to restart parsing.
  1288. *)
  1289.  
  1290. PROCEDURE ComputeRestartPoints (
  1291.       ParseStack    : yyStackType    ;
  1292.       StackSize    : LONGINT    ;
  1293.       StackPtr    : LONGINT    ;
  1294.       VAR RestartSet    : Sets.tSet    );
  1295.    VAR
  1296.       Stack        : yyStackType;
  1297.       State        : LONGINT;
  1298.       Nonterminal    : yySymbolRange;
  1299.       ContinueSet    : Sets.tSet;
  1300.    BEGIN
  1301.       DynArray.MakeArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  1302.       FOR State := 0 TO StackPtr DO
  1303.      Stack^ [State] := ParseStack^ [State];
  1304.       END;
  1305.       Sets.MakeSet (ContinueSet, yyLastTerminal);
  1306.       Sets.AssignEmpty (RestartSet);
  1307.       State := Stack^ [StackPtr];
  1308.  
  1309.       LOOP
  1310.      IF StackPtr >= StackSize THEN
  1311.         DynArray.ExtendArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  1312.      END;
  1313.      Stack^ [StackPtr] := State;
  1314.      ComputeContinuation (Stack, StackSize, StackPtr, ContinueSet);
  1315.      Sets.Union (RestartSet, ContinueSet);
  1316.      State := Next (State, yyContinuation [State]);
  1317.  
  1318.      IF State >= yyFirstFinalState THEN        (* final state ? *)
  1319.         IF State <= yyLastReadTermState THEN    (* read terminal reduce ? *)
  1320.            INC (StackPtr);
  1321.            State := yyFinalToProd [State];
  1322.         END;
  1323.  
  1324.         LOOP                    (* reduce *)
  1325.            IF State = yyStopState THEN
  1326.           DynArray.ReleaseArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  1327.           Sets.ReleaseSet (ContinueSet);
  1328.           RETURN;
  1329.            ELSE 
  1330.           DEC (StackPtr, yyLength [State]);
  1331.           Nonterminal := yyLeftHandSide [State];
  1332.            END;
  1333.  
  1334.            State := Next (Stack^ [StackPtr], Nonterminal);
  1335.            INC (StackPtr);
  1336.            IF State < yyFirstFinalState THEN EXIT; END; (* read nonterminal ? *)
  1337.            State := yyFinalToProd [State];        (* read nonterminal reduce *)
  1338.         END;
  1339.      ELSE                        (* read *)
  1340.         INC (StackPtr);
  1341.      END;
  1342.       END;
  1343.    END ComputeRestartPoints;
  1344.  
  1345. (* access the parse table:   Next : State x Symbol -> State *)
  1346.  
  1347. PROCEDURE Next (State: yyStateRange; Symbol: yySymbolRange): yyStateRange;
  1348.    VAR
  1349.       TCombPtr        : yyTCombTypePtr;
  1350.       NCombPtr        : yyNCombTypePtr;
  1351.    BEGIN
  1352.       IF Symbol <= yyLastTerminal THEN
  1353.      LOOP
  1354.         TCombPtr := yyTCombTypePtr (LONGCARD (yyTBasePtr [State]) 
  1355.                + Symbol * SYSTEM.TSIZE (yyTCombType));
  1356.         IF TCombPtr^.Check # State THEN
  1357.            State := yyDefault [State];
  1358.            IF State = yyNoState THEN RETURN yyNoState; END;
  1359.         ELSE
  1360.            RETURN TCombPtr^.Next;
  1361.         END;
  1362.      END;
  1363.       ELSE
  1364.     NCombPtr := yyNCombTypePtr (LONGCARD (yyNBasePtr [State]) 
  1365.             + Symbol * SYSTEM.TSIZE (yyNCombType));
  1366.     RETURN NCombPtr^;
  1367.       END;
  1368.    END Next;
  1369.  
  1370. PROCEDURE yyGetTables;
  1371.    VAR
  1372.       BlockSize, j, n    : CARDINAL;
  1373.       State    : yyStateRange;
  1374.       TBase    : ARRAY [0 .. yyLastReadState] OF yyTCombRange;
  1375.       NBase    : ARRAY [0 .. yyLastReadState] OF yyNCombRange;
  1376.    BEGIN
  1377.       BlockSize    := 64000 DIV SYSTEM.TSIZE (yyTCombType);
  1378.       yyTableFile := System.OpenInput (ParsTabName);
  1379.       yyErrorCheck (Errors.OpenParseTable, yyTableFile);
  1380.       IF 
  1381.      (yyGetTable (SYSTEM.ADR (TBase            )) DIV SYSTEM.TSIZE (yyTCombRange ) - 1
  1382.         # yyLastReadState) OR
  1383.      (yyGetTable (SYSTEM.ADR (NBase            )) DIV SYSTEM.TSIZE (yyNCombRange ) - 1
  1384.         # yyLastReadState) OR
  1385.      (yyGetTable (SYSTEM.ADR (yyDefault     )) DIV SYSTEM.TSIZE (yyReadRange  ) - 1
  1386.         # yyLastReadState) OR
  1387.      (yyGetTable (SYSTEM.ADR (yyNComb       )) DIV SYSTEM.TSIZE (yyNCombType  )
  1388.         # yyNTableMax - yyLastTerminal) OR
  1389.      (yyGetTable (SYSTEM.ADR (yyLength      )) DIV SYSTEM.TSIZE (yyTableElmt  ) - 1
  1390.         # yyLastReduceState - yyFirstReduceState) OR
  1391.      (yyGetTable (SYSTEM.ADR (yyLeftHandSide)) DIV SYSTEM.TSIZE (yySymbolRange) - 1
  1392.         # yyLastReduceState - yyFirstReduceState) OR
  1393.      (yyGetTable (SYSTEM.ADR (yyContinuation)) DIV SYSTEM.TSIZE (yySymbolRange) - 1
  1394.         # yyLastReadState) OR
  1395.      (yyGetTable (SYSTEM.ADR (yyFinalToProd )) DIV SYSTEM.TSIZE (yyReduceRange) - 1
  1396.         # yyLastReadNontermState - yyFirstReadTermState)
  1397.       THEN
  1398.      Errors.ErrorMessage (Errors.WrongParseTable, Errors.Fatal, Positions.NoPosition);
  1399.       END;
  1400.       n := 0;
  1401.       j := 0;
  1402.       WHILE j <= yyTableMax DO
  1403.      INC (n, yyGetTable (SYSTEM.ADR (yyTComb [j])) DIV SYSTEM.TSIZE (yyTCombType));
  1404.          INC (j, BlockSize);
  1405.       END;
  1406.       IF n # yyTableMax + 1 THEN 
  1407.      Errors.ErrorMessage (Errors.WrongParseTable, Errors.Fatal, Positions.NoPosition);
  1408.       END;
  1409.       System.Close (yyTableFile);
  1410.  
  1411.       FOR State := 1 TO yyLastReadState DO
  1412.      yyTBasePtr [State] := SYSTEM.ADR (yyTComb [TBase [State]]);
  1413.       END;
  1414.       FOR State := 1 TO yyLastReadState DO
  1415.      yyNBasePtr [State] := SYSTEM.ADR (yyNComb [NBase [State]]);
  1416.       END;
  1417.    END yyGetTables;
  1418.  
  1419. PROCEDURE yyGetTable (Address: SYSTEM.ADDRESS): CARDINAL;
  1420.    VAR
  1421.       N        : INTEGER;
  1422.       Length    : yyTableElmt;
  1423.    BEGIN
  1424.       N := System.Read (yyTableFile, SYSTEM.ADR (Length), SYSTEM.TSIZE (yyTableElmt));
  1425.       yyErrorCheck (Errors.ReadParseTable, N);
  1426.       N := System.Read (yyTableFile, Address, Length);
  1427.       yyErrorCheck (Errors.ReadParseTable, N);
  1428.       RETURN Length;
  1429.    END yyGetTable;
  1430.  
  1431. PROCEDURE yyErrorCheck (ErrorCode: INTEGER; Info: INTEGER);
  1432.    VAR ErrNo: INTEGER;
  1433.    BEGIN
  1434.      IF Info < 0 THEN
  1435.     ErrNo := System.ErrNum ();
  1436.     Errors.ErrorMessageI (ErrorCode, Errors.Fatal, Positions.NoPosition,
  1437.        Errors.Integer, SYSTEM.ADR (ErrNo));
  1438.      END;
  1439.    END yyErrorCheck;
  1440.  
  1441. PROCEDURE BeginParser;
  1442.    BEGIN
  1443. (* line 124 "Parser.lalr" *)
  1444.  
  1445.  
  1446.    BeginScanner;
  1447.    NameCount := 0;
  1448.    nNoParameter        := mNoParameter        ();
  1449.    nNoName         := mNoName        ();
  1450.    nNoRule         := mNoRule        ();
  1451.    nNoDesignator    := mNoDesignator    ();
  1452.    nNoStatement        := mNoStatement        ();
  1453.    nNoLayout        := mNoLayout        ();
  1454.    nNoPatternsList    := mNoPatternsList    ();
  1455.  
  1456.  
  1457.       IF NOT yyIsInitialized THEN
  1458.      yyIsInitialized := TRUE;
  1459.      yyGetTables;
  1460.       END;
  1461.    END BeginParser;
  1462.  
  1463. PROCEDURE CloseParser;
  1464.    BEGIN
  1465. (* line 138 "Parser.lalr" *)
  1466.  
  1467.  
  1468.    END CloseParser;
  1469.  
  1470. BEGIN
  1471.     yyIsInitialized := FALSE;
  1472.     ParsTabName := 'Parser.Tab';
  1473. END Parser.
  1474.